import bdb
import uuid

from flask import Response, jsonify, Flask, request, Blueprint,url_for
from configs import *
from modules.Tables import *
from sqlalchemy import func

# 创建蓝图，对应的register目录（激活操作视图）
resource_view = Blueprint('resource', __name__)


# # 算力资源展示
# @resource_view.route('/resource_data', methods=['GET'])
# # @jwt_required()
# def resource_data():
#     # 查找设备全部信息并将结果转换为字典列表
#     resource_list = convert_folder_to_dict_list(
#         db.session.query(Resource_usage).all(),
#         ['id', 'dev_ip', 'dev_id', 'board_temp', 'chip_temp', 'dev_get_sn', 'dev_get_target',
#          'mem_used_mem_total', 'memory_usage_rate', 'tpu_util',])
#
#     # 组装数据 -- 将 dev_get_sn 和 dev_get_target 组合为字符串作为 key 并分组
#     grouped_data = {}
#     for resource in resource_list:
#         # 查找算法配置表中对应的id数量然后进行赋值
#         count = db.session.query(Algorithm_config).filter(Algorithm_config.resource_id==resource.get('id')).count()
#         # 将 dev_get_sn 和 dev_get_target 组合为一个字符串
#         # key = f"{resource['dev_get_target']}-{resource['dev_get_sn']}"  # 这里用字符串拼接
#         key = f"{'YGSJ-TPU'}-{resource['dev_get_sn']}"  # 这里用字符串拼接
#         resource['resource_num']=count
#         if key not in grouped_data:
#             grouped_data[key] = []
#         grouped_data[key].append(resource)
#
#
#     return jsonify({'code':200,'msg':'查询成功','data':grouped_data})

# 算力资源展示
@resource_view.route('/resource_data', methods=['GET'])
@jwt_required()
@jwt_required_with_refresh
def resource_data():
    # 查询所有机器设备关联
    Computing_data = db.session.query(Computing_equipment).all()

    # 初始化最终结果
    final_result = []

    # 当机器设备存在时查询下级对应数据并父子返回
    if Computing_data:
        # 获取所有算法配置的数据，避免重复查询数据库
        all_algorithm_configs = db.session.query(Algorithm_config).all()
        algorithm_config_map = {config.resource_id: config for config in all_algorithm_configs}

        # 遍历每个设备
        for i in Computing_data:
            # 查找该设备的所有资源使用情况
            resource_list = convert_folder_to_dict_list(
                db.session.query(Resource_usage).filter(Resource_usage.computing_id == i.id).all(),
                ['id', 'dev_ip', 'dev_id', 'board_temp', 'chip_temp', 'dev_get_sn', 'dev_get_target',
                 'mem_used_mem_total', 'memory_usage_rate', 'tpu_util']
            )

            # 组装数据 -- 将 dev_get_sn 和 dev_get_target 组合为字符串作为 key 并分组
            grouped_data = {}

            for resource in resource_list:
                # 查找算法配置表中对应的id数量
                resource_id = resource.get('id')
                resource['resource_num'] = len(
                    [config for config in all_algorithm_configs if config.resource_id == resource_id])

                # 使用 dev_get_sn 和 dev_get_target 生成唯一的 key
                key = f"YGSJ-TPU-{resource['dev_get_sn']}"
                # key = f"算力卡{resource['dev_id']+1}"
                # 将资源按 key 进行分组
                if key not in grouped_data:
                    grouped_data[key] = []
                grouped_data[key].append(resource)

            # 将每个设备及其对应的资源分组加入最终结果
            final_result.append({
                'computing_id': i.id,  # 设备基本信息id
                'computing_ip': i.computing_ip,  # 设备基本信息ip
                'computing_name': i.computing_name,  # 设备基本信息名称
                'grouped_resources': grouped_data  # 该设备的所有资源分组
            })

    # 返回最终的 JSON 数据
    return jsonify({'code': 200, 'msg': '查询成功', 'data': final_result})


# 算力设备新增
@resource_view.route('/computing_insert', methods=['POST'])
@jwt_required()
@jwt_required_with_refresh
def computing_insert():

    # 获取请求参数
    computing_ip = strip_whitespace(request.form.get('computing_ip',None))
    computing_name = strip_whitespace(request.form.get('computing_name', None))
    computing_user = strip_whitespace(request.form.get('computing_user', None))
    computing_password = strip_whitespace(request.form.get('computing_password', None))
    prefix = 'YGSJ-'
    random_part = ''.join(random.choices(string.ascii_letters + string.digits, k=10))

    # 组合前缀和随机部分
    computing_code = prefix + random_part


    # 参数构建判断是否为空
    params = [computing_ip,computing_name,computing_user,computing_password]

    if not all(params):
        return jsonify({'code': 400, 'msg': '模板数据有未填写项'})

    if db.session.query(Computing_equipment).filter(Computing_equipment.computing_ip==computing_ip).first():
        return jsonify({'code': 400, 'msg':'该设备已经存在！'})

    # 创建新的记录
    new_computing = Computing_equipment(computing_ip=computing_ip,
                                        computing_name=computing_name,
                                        computing_code=computing_code,
                                        computing_user=computing_user,
                                        computing_password=computing_password,
                                        )
    try:
        # 将新数据添加到数据库会话
        db.session.add(new_computing)
        db.session.commit()  # 提交

        return jsonify({'code': 200, 'msg': '算力设备添加成功！'})

    except Exception as e:

        # 发生异常时回滚事务
        db.session.rollback()
        return jsonify({'code': 500, 'msg': f'算力设备添加失败: {str(e)}'})

# 算力设备删除
@resource_view.route('/computing_delete', methods=['POST'])
@jwt_required()
@jwt_required_with_refresh
# @jwt_required()
def computing_delete():
    try:
        # 获取请求参数
        id = strip_whitespace(request.form.get('id',None))
        # 参数校验
        if not id:
            return jsonify({'code': 400, 'msg': '要删除ID未填写'})

        # 查询模板数据
        computing_detail = db.session.query(Computing_equipment).filter(Computing_equipment.id==id).first()
        if not computing_detail:
            return jsonify({'code': 404, 'msg': '算力机器不存在'})
        else:
            db.session.query(Computing_equipment).filter(Computing_equipment.id==id).delete()

        # 提交修改
        db.session.commit()

        return jsonify({'code': 200, 'msg': '删除成功'})

    except SQLAlchemyError as e:
        db.session.rollback()  # 发生异常时回滚事务
        return jsonify({'code': 500, 'msg': f'数据库错误: {str(e)}'})

    except Exception as e:
        return jsonify({'code': 500, 'msg': f'服务器错误: {str(e)}'})



# 算力设备修改
@resource_view.route('/computing_update', methods=['POST'])
@jwt_required()
@jwt_required_with_refresh
# @jwt_required()
def computing_update():
    try:

        # 获取请求参数
        id = strip_whitespace(request.form.get('id',None))
        computing_ip = strip_whitespace(request.form.get('computing_ip', None))
        computing_name = strip_whitespace(request.form.get('computing_name', None))
        computing_user = strip_whitespace(request.form.get('computing_user', None))
        computing_password = strip_whitespace(request.form.get('computing_password', None))

        # 查询模板数据
        computing_detail = db.session.query(Computing_equipment).filter(Computing_equipment.id==id).first()
        if not computing_detail:
            return jsonify({'code': 404, 'msg': '算力设备不存在'})

        if computing_ip is not None:
            computing_detail.computing_ip = computing_ip
        if computing_name is not None :
            computing_detail.computing_name = computing_name
        if computing_user is not None :
            computing_detail.computing_user = computing_user
        if computing_password is not None :
            computing_detail.computing_password = computing_password

        # 提交修改
        db.session.commit()

        return jsonify({'code': 200, 'msg': '修改成功'})

    except SQLAlchemyError as e:
        db.session.rollback()  # 发生异常时回滚事务
        return jsonify({'code': 500, 'msg': f'数据库错误: {str(e)}'})

    except Exception as e:
        return jsonify({'code': 500, 'msg': f'服务器错误: {str(e)}'})



# 算力设备展示
@resource_view.route('/computing_show', methods=['GET'])
@jwt_required()
@jwt_required_with_refresh
def computing_show():
    """
    算法模板信息展示（支持分页）
    page（str）： 当前页码
    per_page（str）： 每页显示条目数量
    """

    # 获取分页参数
    page = request.args.get('page', default=1, type=int)  # 当前页码
    per_page = request.args.get('per_page', default=15, type=int)  # 每页显示条目数量

    # 查询主区域点并进行分页
    pagination = db.session.query(Computing_equipment).paginate(page=page, per_page=per_page, error_out=False)


    # 获取分页后的数据
    data_list = [
        {
            'id': item.id,
            'computing_ip': item.computing_ip,
            'computing_name': item.computing_name,
            'computing_user': item.computing_user,
            'computing_password': item.computing_password,
            'computing_code': item.computing_code,
            'created_at': item.created_at,
            'updated_at': item.updated_at,

        }
        for item in pagination.items
    ]

    # 构造返回结果，包括分页信息
    response = {
        'code': 200,
        'data': data_list,
        'pagination': {
            'current_page': pagination.page,
            'total_pages': pagination.pages,
            'total_items': pagination.total,
            'per_page': pagination.per_page
        }
    }

    return jsonify({'code':200,'data':response})


